// 引入 API 工具和存储工具
const api = require('../../utils/api.js');
const storage = require('../../utils/storage.js');
const permission = require('../../utils/permission.js'); // 🎯 引入权限工具

Page({
  data: {
    statusBarHeight: 0,
    navbarHeight: 0,
    title: '',
    location: '请选择地点',
    latitude: 37.463822,   // 🔥 默认纬度（烟台）
    longitude: 121.447935,  // 🔥 默认经度（烟台）
    startDate: '',
    startTimeValue: '',
    endDate: '',
    endTimeValue: '',
    limitType: '无限制',
    peopleNum: '',
    payType: '我买单',
    detail: '',
    detailLength: 0,
    images: [],
    
    // 弹窗控制
    showLimitPicker: false,
    showPayPicker: false,
    
    limitOptions: ['无限制', '男', '女'],
    payOptions: ['我买单', 'AA', '双方商议'],
    
    // 🔥 发布状态
    isPublishing: false
  },

  onLoad() {
    // 🔥 首先检查实名认证状态
    if (!this.checkRealNameAuth()) {
      return; // 如果未实名认证，终止页面加载
    }

    // 🎯 初始化权限系统（根据用户积分计算权限）
    permission.initializePermissions();
    
    // 获取系统状态栏高度
    const systemInfo = wx.getSystemInfoSync();
    const statusBarHeight = systemInfo.statusBarHeight;
    const navbarHeight = statusBarHeight + 44; // 44px 是导航栏内容高度
    
    // 获取当前日期和时间作为默认值
    const now = new Date();
    const year = now.getFullYear();
    const month = String(now.getMonth() + 1).padStart(2, '0');
    const day = String(now.getDate()).padStart(2, '0');
    const hour = String(now.getHours()).padStart(2, '0');
    const minute = String(now.getMinutes()).padStart(2, '0');
    const currentDate = `${year}-${month}-${day}`;
    const currentTime = `${hour}:${minute}`;
    
    this.setData({
      statusBarHeight: statusBarHeight,
      navbarHeight: navbarHeight,
      startDate: currentDate,
      startTimeValue: currentTime,
      endDate: currentDate,
      endTimeValue: currentTime
    });
    
    // 🔥 页面加载时尝试获取当前位置
    this.getCurrentLocation();
  },

  // 🔥 检查实名认证状态
  checkRealNameAuth() {
    console.log('🔍 检查实名认证状态...');
    
    // 获取用户信息
    const userInfo = storage.getUserInfo();
    
    if (!userInfo) {
      console.log('❌ 用户未登录');
      wx.showModal({
        title: '提示',
        content: '请先登录',
        showCancel: false,
        success: () => {
          wx.reLaunch({
            url: '/pages/login/index'
          });
        }
      });
      return false;
    }
    
    // 检查是否已实名认证
    const realNameAuth = userInfo.extraData?.realNameAuth;
    const isVerified = realNameAuth?.verified === true;
    
    console.log('📋 实名认证状态:', {
      hasRealNameAuth: !!realNameAuth,
      verified: isVerified,
      name: realNameAuth?.name || '未设置'
    });
    
    if (!isVerified) {
      console.log('⚠️ 用户未实名认证，需要先完成实名认证');
      wx.showModal({
        title: '实名认证提示',
        content: '发布活动需要先完成实名认证，是否前往认证？',
        confirmText: '去认证',
        cancelText: '取消',
        confirmColor: '#D84545',
        success: (res) => {
          if (res.confirm) {
            console.log('✅ 用户确认前往实名认证');
            wx.redirectTo({
              url: '/pages/verify/index'
            });
          } else {
            console.log('❌ 用户取消实名认证，强制返回上一页或首页');
            // 🔥 尝试返回上一页
            wx.navigateBack({
              fail: () => {
                // 🔥 如果返回失败（比如是从首页直接进入的），跳转到首页
                console.log('⚠️ 无法返回上一页，跳转到首页');
                wx.switchTab({
                  url: '/pages/main/index'
                });
              }
            });
          }
        },
        fail: () => {
          // 🔥 弹窗失败时也强制返回
          console.log('❌ 弹窗显示失败，强制返回');
          wx.navigateBack({
            fail: () => {
              wx.switchTab({
                url: '/pages/main/index'
              });
            }
          });
        }
      });
      return false;
    }
    
    console.log('✅ 实名认证检查通过');
    return true;
  },

  onShow() {
    // 🔔 自动初始化通知组件
    const app = getApp();
    app.autoInitNotification();
  },

  // 🔥 获取当前位置
  getCurrentLocation() {
    console.log('📍 尝试获取当前位置...');
    
    // 先显示"定位中..."
    this.setData({
      location: '定位中...'
    });
    
    wx.getLocation({
      type: 'gcj02',
      success: (res) => {
        console.log('✅ 获取当前位置成功:', res);
        
        // 保存经纬度
        this.setData({
          latitude: res.latitude,
          longitude: res.longitude
        });
        
        // 🔥 调用高德地图API获取地址名称
        this.getAddressFromLocation(res.latitude, res.longitude);
      },
      fail: (err) => {
        console.warn('⚠️ 获取当前位置失败:', err);
        console.warn('   将使用默认位置（烟台），请用户手动选择位置');
        
        // 获取失败时，提示用户选择位置
        this.setData({
          location: '请选择地点'
        });
      }
    });
  },

  // 🔥 根据经纬度获取地址名称（高德地图逆地理编码）
  getAddressFromLocation(latitude, longitude) {
    console.log('🗺️ 获取地址名称:', { latitude, longitude });
    
    const aMapKey = 'b2dec638f9508c079a4da1c7262ca67a'; // 使用地图页面相同的key
    
    wx.request({
      url: 'https://restapi.amap.com/v3/geocode/regeo',
      data: {
        key: aMapKey,
        location: `${longitude},${latitude}`,
        extensions: 'base'
      },
      success: (res) => {
        console.log('✅ 获取地址成功:', res.data);
        
        if (res.data.status === '1' && res.data.regeocode) {
          const regeocode = res.data.regeocode;
          const formattedAddress = regeocode.formatted_address;
          
          // 优先使用POI名称，否则使用详细地址
          let address = formattedAddress;
          if (regeocode.pois && regeocode.pois.length > 0) {
            const poi = regeocode.pois[0];
            address = poi.name || formattedAddress;
          }
          
          console.log('📍 设置地址:', address);
          this.setData({
            location: address
          });
        } else {
          console.warn('⚠️ 地址解析失败，使用坐标显示');
          this.setData({
            location: `${latitude.toFixed(4)}, ${longitude.toFixed(4)}`
          });
        }
      },
      fail: (err) => {
        console.error('❌ 获取地址失败:', err);
        // API调用失败，显示坐标
        this.setData({
          location: `${latitude.toFixed(4)}, ${longitude.toFixed(4)}`
        });
      }
    });
  },

  // 标题输入
  onTitleInput(e) {
    this.setData({ title: e.detail.value });
  },

  // 选择地点
  chooseLocation() {
    const { location, latitude, longitude } = this.data;
    console.log('📍 跳转到地图页面，当前位置:', { location, latitude, longitude });
    wx.navigateTo({
      url: `/pages/map/index?location=${encodeURIComponent(location)}&latitude=${latitude}&longitude=${longitude}`
    });
  },

  // 🔥 刷新定位（点击定位图标时调用）
  refreshLocation() {
    console.log('🔄 点击刷新定位按钮');
    
    wx.showToast({ title: '定位中...', icon: 'loading' });
    
    wx.getLocation({
      type: 'gcj02',
      success: (res) => {
        console.log('✅ 刷新定位成功:', res);
        
        // 保存经纬度
        this.setData({
          latitude: res.latitude,
          longitude: res.longitude,
          location: '获取地址中...'
        });
        
        // 🔥 调用高德地图API获取地址名称
        this.getAddressFromLocation(res.latitude, res.longitude);
        
        // 延迟显示成功提示，等待地址获取完成
        setTimeout(() => {
          wx.showToast({ title: '定位成功', icon: 'success', duration: 1500 });
        }, 500);
      },
      fail: (err) => {
        console.error('❌ 刷新定位失败:', err);
        wx.hideToast();
        wx.showToast({ title: '定位失败，请手动选择位置', icon: 'none', duration: 2000 });
      }
    });
  },

  // 开始日期选择
  onStartDateChange(e) {
    this.setData({
      startDate: e.detail.value
    }, () => {
      // 选择开始日期后验证时间
      this.validateEndTime();
    });
  },

  // 开始时间选择
  onStartTimeChange(e) {
    this.setData({
      startTimeValue: e.detail.value
    }, () => {
      // 选择开始时间后验证时间
      this.validateEndTime();
    });
  },

  // 结束日期选择
  onEndDateChange(e) {
    this.setData({
      endDate: e.detail.value
    }, () => {
      // 选择结束日期后验证时间
      this.validateEndTime();
    });
  },

  // 结束时间选择
  onEndTimeChange(e) {
    this.setData({
      endTimeValue: e.detail.value
    }, () => {
      // 选择结束时间后验证时间
      this.validateEndTime();
    });
  },

  // 🔥 验证结束时间是否大于开始时间，并限制最长7天
  validateEndTime(showToast = true) {
    const { startDate, startTimeValue, endDate, endTimeValue } = this.data;
    
    // 如果任何一个时间没有设置，不进行验证
    if (!startDate || !startTimeValue || !endDate || !endTimeValue) {
      return true;
    }
    
    try {
      // 🔥 修复 iOS 兼容性：使用 "/" 分隔符替代 "-"
      const startDateIOS = startDate.replace(/-/g, '/');
      const endDateIOS = endDate.replace(/-/g, '/');
      const startDateTime = new Date(`${startDateIOS} ${startTimeValue}`);
      const endDateTime = new Date(`${endDateIOS} ${endTimeValue}`);
      
      console.log('⏰ 时间验证:');
      console.log('   开始时间:', startDateTime);
      console.log('   结束时间:', endDateTime);
      
      // 🔥 计算时间差（分钟和天数）
      const timeDiffMs = endDateTime - startDateTime;
      const timeDiffMinutes = timeDiffMs / (1000 * 60);
      const timeDiffDays = timeDiffMs / (1000 * 60 * 60 * 24);
      
      // 验证1：结束时间必须大于开始时间
      if (timeDiffMs <= 0) {
        console.log('❌ 结束时间必须大于开始时间');
        if (showToast) {
          wx.showToast({
            title: '结束时间必须大于开始时间',
            icon: 'none',
            duration: 2000
          });
        }
        return false;
      }
      
      // 验证2：活动时长至少30分钟
      if (timeDiffMinutes < 30) {
        console.log('⚠️ 活动时长较短:', timeDiffMinutes, '分钟');
        if (showToast) {
          wx.showToast({
            title: '活动时长至少需要30分钟',
            icon: 'none',
            duration: 2000
          });
        }
        return false;
      }
      
      // 验证3：活动时长最多7天（168小时）
      if (timeDiffDays > 7) {
        console.log('❌ 活动时长超过7天限制:', timeDiffDays.toFixed(2), '天');
        if (showToast) {
          wx.showToast({
            title: '活动时长最多7天',
            icon: 'none',
            duration: 2000
          });
        }
        return false;
      }
      
      console.log('✅ 时间验证通过');
      console.log('   时长:', timeDiffMinutes.toFixed(0), '分钟 (', timeDiffDays.toFixed(2), '天)');
      return true;
    } catch (e) {
      console.error('❌ 时间验证失败:', e);
      return false;
    }
  },

  // 获取完整的开始时间
  getStartDateTime() {
    const { startDate, startTimeValue } = this.data;
    return `${startDate} ${startTimeValue}`;
  },

  // 获取完整的结束时间
  getEndDateTime() {
    const { endDate, endTimeValue } = this.data;
    return `${endDate} ${endTimeValue}`;
  },

  // 显示限制选择器
  showLimitPicker() {
    this.setData({ showLimitPicker: true });
  },

  // 选择限制
  selectLimit(e) {
    const { value } = e.currentTarget.dataset;
    this.setData({
      limitType: value,
      showLimitPicker: false
    });
  },

  // 显示消费选择器
  showPayPicker() {
    this.setData({ showPayPicker: true });
  },

  // 选择消费方式
  selectPay(e) {
    const { value } = e.currentTarget.dataset;
    this.setData({
      payType: value,
      showPayPicker: false
    });
  },

  // 关闭弹窗
  closePicker() {
    this.setData({
      showLimitPicker: false,
      showPayPicker: false
    });
  },

  // 人数输入
  onPeopleInput(e) {
    this.setData({ peopleNum: e.detail.value });
  },

  // 详情输入
  onDetailInput(e) {
    const value = e.detail.value;
    this.setData({
      detail: value,
      detailLength: value.length
    });
  },

  // 选择图片
  chooseImage() {
    const { images } = this.data;
    if (images.length >= 4) {
      wx.showToast({ title: '最多上传4张', icon: 'none' });
      return;
    }

    wx.chooseImage({
      count: 4 - images.length,
      success: (res) => {
        this.setData({
          images: [...images, ...res.tempFilePaths]
        });
      }
    });
  },

  // 删除图片
  deleteImage(e) {
    const { index } = e.currentTarget.dataset;
    const { images } = this.data;
    images.splice(index, 1);
    this.setData({ images });
  },

  // 返回
  goBack() {
    wx.navigateBack();
  },

  // 🔥 重置表单数据
  resetFormData() {
    console.log('🔄 重置表单数据...');
    
    // 获取当前时间作为默认值
    const now = new Date();
    const year = now.getFullYear();
    const month = String(now.getMonth() + 1).padStart(2, '0');
    const day = String(now.getDate()).padStart(2, '0');
    const hour = String(now.getHours()).padStart(2, '0');
    const minute = String(now.getMinutes()).padStart(2, '0');
    const currentDate = `${year}-${month}-${day}`;
    const currentTime = `${hour}:${minute}`;
    
    this.setData({
      title: '',
      location: '请选择地点',
      latitude: 37.463822,   // 🔥 默认烟台坐标
      longitude: 121.447935,  // 🔥 默认烟台坐标
      startDate: currentDate,
      startTimeValue: currentTime,
      endDate: currentDate,
      endTimeValue: currentTime,
      limitType: '无限制',
      peopleNum: '',
      payType: '我买单',
      detail: '',
      detailLength: 0,
      images: [],
      isPublishing: false
    });
    
    console.log('✅ 表单数据已重置');
    
    // 🔥 重新获取当前位置
    this.getCurrentLocation();
  },

  // 🔥 计算活动持续时间（小时）
  calculateDuration() {
    const { startDate, startTimeValue, endDate, endTimeValue } = this.data;
    
    if (!startDate || !startTimeValue || !endDate || !endTimeValue) {
      return 0;
    }
    
    try {
      // 🔥 修复 iOS 兼容性：使用 "/" 分隔符替代 "-"
      const startDateIOS = startDate.replace(/-/g, '/');
      const endDateIOS = endDate.replace(/-/g, '/');
      const startDateTime = new Date(`${startDateIOS} ${startTimeValue}`);
      const endDateTime = new Date(`${endDateIOS} ${endTimeValue}`);
      
      const durationMs = endDateTime - startDateTime;
      const durationHours = durationMs / (1000 * 60 * 60);
      
      return Math.round(durationHours * 10) / 10; // 保留1位小数
    } catch (e) {
      console.error('❌ 计算持续时间失败:', e);
      return 0;
    }
  },

  // 🖼️ 批量上传活动图片
  async uploadImages(images, userId) {
    console.log('📤 =============== 开始批量上传图片 ===============');
    console.log('📊 图片数量:', images.length);
    
    if (images.length === 0) {
      console.log('⚠️ 没有图片需要上传');
      return [];
    }
    
    const uploadedUrls = [];
    
    try {
      for (let i = 0; i < images.length; i++) {
        const tempPath = images[i];
        console.log(`📤 上传第 ${i + 1}/${images.length} 张图片: ${tempPath}`);
        
        wx.showLoading({
          title: `上传图片 ${i + 1}/${images.length}`,
          mask: true
        });
        
        try {
          const result = await api.uploadActivityImage(userId, tempPath);
          console.log(`✅ 第 ${i + 1} 张图片上传成功:`, result.image_url);
          uploadedUrls.push(result.image_url);
        } catch (error) {
          console.error(`❌ 第 ${i + 1} 张图片上传失败:`, error);
          wx.hideLoading();
          throw new Error(`第 ${i + 1} 张图片上传失败`);
        }
      }
      
      wx.hideLoading();
      console.log('✅ 所有图片上传成功:', uploadedUrls);
      return uploadedUrls;
    } catch (error) {
      wx.hideLoading();
      console.error('❌ 图片上传过程出错:', error);
      throw error;
    }
  },

  // 🔥 发布活动（对接真实 API）
  async publishActivity() {
    console.log('🚀 =============== 开始发布活动 ===============');
    
    const { 
      title, 
      detail, 
      location, 
      latitude, 
      longitude,
      startDate, 
      startTimeValue,
      endDate,
      endTimeValue,
      peopleNum, 
      limitType, 
      payType,
      images,
      isPublishing
    } = this.data;

    // 🔥 防止重复提交
    if (isPublishing) {
      console.log('⚠️ 正在发布中，请勿重复点击');
      return;
    }

    // ✅ 表单验证
    if (!title) {
      wx.showToast({ title: '请输入标题', icon: 'none' });
      return;
    }

    if (!startDate || !startTimeValue) {
      wx.showToast({ title: '请选择开始时间', icon: 'none' });
      return;
    }

    if (!endDate || !endTimeValue) {
      wx.showToast({ title: '请选择结束时间', icon: 'none' });
      return;
    }

    // 🔥 验证结束时间必须大于开始时间
    if (!this.validateEndTime()) {
      console.log('❌ 时间验证未通过，停止发布');
      return;
    }

    if (!peopleNum) {
      wx.showToast({ title: '请输入参与人数', icon: 'none' });
      return;
    }

    if (!detail) {
      wx.showToast({ title: '请输入活动详情', icon: 'none' });
      return;
    }

    // 🔥 检查登录状态
    const userInfo = storage.getUserInfo();
    if (!userInfo || !userInfo.userid) {
      wx.showToast({
        title: '请先登录',
        icon: 'none',
        success: () => {
          setTimeout(() => {
            wx.navigateTo({ url: '/pages/login/index' });
          }, 1500);
        }
      });
      return;
    }

    // 🔥 二次检查实名认证状态（发布按钮保护）
    const realNameAuth = userInfo.extraData?.realNameAuth;
    const isVerified = realNameAuth?.verified === true;
    
    if (!isVerified) {
      console.log('❌ 发布时检测到未实名认证');
      wx.showModal({
        title: '实名认证提示',
        content: '发布活动需要先完成实名认证，是否前往认证？',
        confirmText: '去认证',
        cancelText: '取消',
        confirmColor: '#D84545',
        success: (res) => {
          if (res.confirm) {
            wx.navigateTo({
              url: '/pages/verify/index'
            });
          }
        }
      });
      return;
    }

    console.log('✅ 表单验证通过');
    console.log('👤 当前用户:', userInfo);

    // 🔥 设置发布中状态
    this.setData({ isPublishing: true });

    // 显示检测中提示
    wx.showLoading({
      title: '内容检测中...',
      mask: true
    });

    try {
      // 🔒 调用内容安全检测接口（自动从 storage 读取 openid）
      // 检测内容：标题 + 详情（用换行符分隔）
      const contentToCheck = `${title}\n${detail}`;
      
      const checkResult = await api.checkContentSecurity(
        contentToCheck,
        4,  // 场景：4=社交日志（发布活动）
        {
          title: title,
          nickname: userInfo.username || '用户'
        }
      );

      wx.hideLoading();
      
      console.log('✅ 内容安全检测完成:', checkResult);

      // 🔥 根据检测结果处理
      const suggest = checkResult.result.suggest;
      const message = checkResult.result.message || '内容检测完成';

      if (suggest === 'pass') {
        // ✅ 内容安全，继续发布
        console.log('✅ 内容安全，允许发布');
        this.proceedWithPublish();
      } else if (suggest === 'review') {
        // ⚠️ 内容需要审核 - 视为违规，不允许发布
        console.log('⚠️ 内容需要审核，视为违规');
        this.setData({ isPublishing: false });
        wx.showModal({
          title: '内容违规',
          content: '有违规内容，请修改后再发布！',
          showCancel: false,
          confirmColor: '#D84545'
        });
      } else if (suggest === 'risky') {
        // ❌ 内容违规，禁止发布
        console.log('❌ 内容违规，禁止发布');
        this.setData({ isPublishing: false });
        wx.showModal({
          title: '内容违规',
          content: '有违规内容，请修改后再发布！',
          showCancel: false,
          confirmColor: '#D84545'
        });
      } else {
        // 未知状态，也视为违规，不允许发布
        console.warn('⚠️ 未知的检测结果:', suggest);
        this.setData({ isPublishing: false });
        wx.showModal({
          title: '内容违规',
          content: '有违规内容，请修改后再发布！',
          showCancel: false,
          confirmColor: '#D84545'
        });
      }

    } catch (error) {
      wx.hideLoading();
      console.error('❌ 内容安全检测失败:', error);
      this.setData({ isPublishing: false });
      
      // 检测失败也不允许发布
      wx.showModal({
        title: '检测失败',
        content: '内容安全检测服务暂时不可用，请稍后再试',
        showCancel: false,
        confirmColor: '#D84545'
      });
    }
  },

  // 🔥 实际发布活动的逻辑（从原 publishActivity 中提取）
  async proceedWithPublish() {
    console.log('🚀 =============== 开始实际发布流程 ===============');
    
    const { 
      title, 
      detail, 
      location, 
      latitude, 
      longitude,
      startDate, 
      startTimeValue,
      endDate,
      endTimeValue,
      peopleNum, 
      limitType, 
      payType,
      images
    } = this.data;

    const userInfo = storage.getUserInfo();

    // 🖼️ 先上传图片（如果有的话）
    let uploadedImageUrls = [];
    if (images.length > 0) {
      try {
        uploadedImageUrls = await this.uploadImages(images, userInfo.userid);
        console.log('✅ 图片上传完成，URL列表:', uploadedImageUrls);
      } catch (error) {
        console.error('❌ 图片上传失败:', error);
        this.setData({ isPublishing: false });
        wx.showToast({
          title: error.message || '图片上传失败',
          icon: 'none',
          duration: 2000
        });
        return;
      }

      // 🔒 图片上传成功后，调用图片内容安全检测
      if (uploadedImageUrls.length > 0) {
        console.log('🔍 开始检测图片内容安全...');
        wx.showLoading({
          title: '图片检测中...',
          mask: true
        });

        try {
          // 批量检测所有图片（异步接口，立即返回 trace_id）
          const imageCheckResults = await api.checkMultipleImages(
            uploadedImageUrls,
            4  // 场景：4=社交日志（发布活动）
          );
          
          wx.hideLoading();
          console.log('✅ 图片检测已提交:', imageCheckResults);
          
          // 🔥 由于是异步检测，这里只获取 trace_id，实际结果由后端推送处理
          // 记录 trace_id 以便后续追踪（可选）
          const traceIds = imageCheckResults.map(r => r.trace_id).filter(id => id);
          console.log('📋 图片检测 trace_ids:', traceIds);
          
          // 继续发布流程（不阻塞）
        } catch (error) {
          wx.hideLoading();
          console.error('❌ 图片检测失败:', error);
          this.setData({ isPublishing: false });
          
          // 🔥 图片检测失败：直接禁止发布
          wx.showModal({
            title: '图片检测失败',
            content: '图片安全检测服务暂时不可用，请稍后再试或移除图片后发布',
            showCancel: false,
            confirmColor: '#D84545'
          });
          return;
        }
      }
    }

    // 🕒 格式化时间（与 Flutter playtrue3 一致）
    const activityPublishTime = `${startDate} ${startTimeValue}:00`;
    const activityEndTime = `${endDate} ${endTimeValue}:00`;
    
    console.log('🕒 活动开始时间:', activityPublishTime);
    console.log('🕒 活动结束时间:', activityEndTime);

    // 🎨 构建活动类型数组（与 Flutter playtrue3 一致）
    const activityType = [payType];
    if (limitType !== '无限制') {
      activityType.push(limitType);
    }

    // 🎯 计算发布权限（🔥 微信免费开放：直接返回免费，不再检查积分）
    let freeValue;
    try {
      freeValue = permission.calculatePublishActivityFree();
      console.log('✅ 权限计算成功，free =', freeValue);
    } catch (error) {
      // 🔥 微信免费开放：此段积分不足逻辑已禁用（permission.calculatePublishActivityFree()直接返回免费，不会抛异常）
      console.error('❌ 权限计算失败:', error.message);
      this.setData({ isPublishing: false });
      wx.showModal({
        title: '提示',
        content: error.message,
        showCancel: true,
        confirmText: '去充值',
        cancelText: '取消',
        success: (res) => {
          if (res.confirm) {
            wx.navigateTo({
              url: '/pages/funds/index'
            });
          }
        }
      });
      return;
    }

    // 🔥 构建活动数据对象（与 Flutter playtrue3 完全一致）
    const activityData = {
      // ✅ 必填参数
      activityTitle: title,
      publisherId: userInfo.userid,
      publisherNickname: userInfo.username || '未知用户',
      activityPublishTime: activityPublishTime,  // 开始时间
      latitude: latitude,
      longitude: longitude,
      
      // 可选参数
      activityDetails: detail,
      activityLocation: location,
      activityImages: uploadedImageUrls.length > 0 ? uploadedImageUrls : undefined,  // 🖼️ 使用上传后的图片URL
      activityType: activityType,                               // 活动类型数组
      activityTags: [],                                         // 标签数组（暂时为空）
      activityMaxParticipants: parseInt(peopleNum),            // 最大参与人数
      publisherAvatarUrl: userInfo.userAvatarUrl || undefined, // 发布者头像
      publisherSignature: userInfo.userSignature || undefined, // 发布者签名
      publisherTags: userInfo.userTags || ['新用户'],          // 发布者标签
      publisherPoints: userInfo.userPoints || 0,                // 发布者积分
      
      // 🔥 关键：extraData 包含结束时间（与 Flutter playtrue3 一致）
      extraData: {
        activityEndTime: activityEndTime,  // 结束时间
        duration: this.calculateDuration()  // 持续时间（小时）
      },
      
      // 🎯 动态计算免费发布权限（新规则：0=付费, 1=免费）
      free: freeValue
    };

    console.log('📊 活动数据对象:', activityData);

    // 🚀 调用发布活动 API
    api.publishActivity(activityData)
      .then(response => {
        console.log('✅ 活动发布成功:', response);
        
        // 🎯 增加发布活动计数（模仿MyApplication2）
        permission.incrementPublishActivityCount();
        
        // 🎯 处理积分变化并更新权限（模仿MyApplication2的changeUserPoints）
        const pointsChange = response.pointsChange || 0;
        if (pointsChange !== 0) {
          permission.changeUserPoints(pointsChange);
        }
        
        // 🔥 发布成功后立即清空表单数据
        this.resetFormData();
        
        // 显示成功提示
        const successMessage = response.message || '发布成功';
        const pointsMessage = pointsChange > 0 
          ? `\n获得积分: +${pointsChange}` 
          : (pointsChange < 0 ? `\n消耗积分: ${Math.abs(pointsChange)}` : '');
        
        wx.showToast({
          title: successMessage + pointsMessage,
          icon: 'success',
          duration: 2000,
          success: () => {
            // 延迟跳转到一起玩页面
            setTimeout(() => {
              wx.switchTab({
                url: '/pages/together/index'
              });
            }, 1500);
          }
        });
      })
      .catch(error => {
        console.error('❌ 活动发布失败:', error);
        wx.showToast({
          title: error.message || '发布失败，请重试',
          icon: 'none',
          duration: 2000
        });
      })
      .finally(() => {
        // 🔥 恢复发布状态（重置方法中已经包含了，但保险起见还是保留）
        this.setData({ isPublishing: false });
      });
  }
});

